{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "<center>\n",
    "<img src=\"https://raw.githubusercontent.com/Yorko/mlcourse.ai/master/img/ods_stickers.jpg\" />\n",
    "    \n",
    "# [mlcourse.ai](https://mlcourse.ai) - Cours Open Machine Learning\n",
    "\n",
    "<center>\n",
    "Auteur: [Egor Polusmak](https://www.linkedin.com/in/egor-polusmak/). Traduit et édité par Alena Sharlo, [Yury Kashnitsky](https://yorko.github.io), [Artem Trunov](https://www.linkedin.com/in/datamove), [Anastasia Manokhina](https: //www.linkedin.com/in/anastasiamanokhina/), [Yuanyuan Pao](https://www.linkedin.com/in/yuanyuanpao/) et [Ousmane Cissé](https://www.linkedin.com/in/ousmane-cissé).  \n",
    "<center>\n",
    "Ce matériel est soumis aux termes et conditions de la licence [Creative Commons CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/).  \n",
    "L'utilisation gratuite est autorisée à des fins non commerciales."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "# <center>Topic 2. Analyse visuelle des données en Python\n",
    "## <center>Partie 2. Présentation des bibliothèques Seaborn, Matplotlib et Plotly"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Plan\n",
    "\n",
    "1. [Dataset](#1.-Dataset)\n",
    "2. [DataFrame.plot()](#2.-DataFrame.plot)\n",
    "3. [Seaborn](#3.-Seaborn)\n",
    "4. [Plotly](#4.-Plotly)\n",
    "5. [Demo assignment](#5.-Demo-assignment)\n",
    "6. [Useful resources](#6.-Useful-resources)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 1. Dataset (Jeu de données)\n",
    "\n",
    "Tout d'abord, nous allons configurer notre environnement en important toutes les bibliothèques nécessaires. Nous allons également modifier les paramètres d'affichage pour mieux afficher les tracés."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:09:59.648652Z",
     "start_time": "2020-02-16T11:09:55.238985Z"
    }
   },
   "outputs": [],
   "source": [
    "# Matplotlib forms basis for visualization in Python\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "# We will use the Seaborn library\n",
    "import seaborn as sns\n",
    "\n",
    "sns.set()\n",
    "\n",
    "# Graphics in SVG format are more sharp and legible\n",
    "%config InlineBackend.figure_format = 'svg'\n",
    "\n",
    "# Increase the default plot size and set the color scheme\n",
    "plt.rcParams[\"figure.figsize\"] = (8, 5)\n",
    "plt.rcParams[\"image.cmap\"] = \"viridis\"\n",
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Maintenant, chargeons l'ensemble de données que nous utiliserons dans un «DataFrame». J'ai choisi un ensemble de données sur les ventes et les évaluations de jeux vidéo dans [Kaggle Datasets](https://www.kaggle.com/rush4ratio/video-game-sales-with-ratings).  \n",
    "Certains jeux de cet ensemble de données manquent de notes; Par conséquent, filtrons uniquement les exemples dont toutes les valeurs sont présentes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:14:34.491578Z",
     "start_time": "2020-02-16T11:14:33.354Z"
    }
   },
   "outputs": [],
   "source": [
    "df = pd.read_csv(\n",
    "    \"https://raw.githubusercontent.com/Yorko/mlcourse.ai/master/data/video_games_sales.csv\"\n",
    ").dropna()\n",
    "print(df.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Ensuite, affichons le résumé du `DataFrame` pour vérifier les types de données et pour vérifier que tout n'est pas nul."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:14:57.409622Z",
     "start_time": "2020-02-16T11:14:57.316584Z"
    }
   },
   "outputs": [],
   "source": [
    "df.info()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Nous voyons que `pandas` a chargé certaines des caractéristiques numériques en tant que type` objet`. Nous convertirons explicitement ces colonnes en `float` et` int`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:15:23.914929Z",
     "start_time": "2020-02-16T11:15:23.71513Z"
    }
   },
   "outputs": [],
   "source": [
    "df[\"User_Score\"] = df[\"User_Score\"].astype(\"float64\")\n",
    "df[\"Year_of_Release\"] = df[\"Year_of_Release\"].astype(\"int64\")\n",
    "df[\"User_Count\"] = df[\"User_Count\"].astype(\"int64\")\n",
    "df[\"Critic_Count\"] = df[\"Critic_Count\"].astype(\"int64\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Le «DataFrame» résultant contient 6825 exemples et 16 colonnes.  \n",
    "Regardons les premières entrées avec la méthode `head ()` pour vérifier que tout a été correctement analysé.  \n",
    "Pour le rendre plus pratique, je n'ai listé que les variables que nous utiliserons dans ce cahier."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:16:06.434975Z",
     "start_time": "2020-02-16T11:16:06.30423Z"
    }
   },
   "outputs": [],
   "source": [
    "useful_cols = [\n",
    "    \"Name\",\n",
    "    \"Platform\",\n",
    "    \"Year_of_Release\",\n",
    "    \"Genre\",\n",
    "    \"Global_Sales\",\n",
    "    \"Critic_Score\",\n",
    "    \"Critic_Count\",\n",
    "    \"User_Score\",\n",
    "    \"User_Count\",\n",
    "    \"Rating\",\n",
    "]\n",
    "df[useful_cols].head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 2. DataFrame.plot ()\n",
    "\n",
    "Avant de passer à Seaborn et Plotly, discutons de la manière la plus simple et souvent la plus pratique de visualiser les données d'un `DataFrame`: en utilisant sa propre méthode `plot()`.\n",
    "\n",
    "Par exemple, nous allons créer un graphique des ventes de jeux vidéo par pays et par année.  \n",
    "Tout d'abord, ne conservons que les colonnes dont nous avons besoin. Ensuite, nous calculerons le total des ventes par année et appellerons la méthode `plot()` sur le `DataFrame` résultant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:17:09.250903Z",
     "start_time": "2020-02-16T11:17:06.818253Z"
    }
   },
   "outputs": [],
   "source": [
    "df[[x for x in df.columns if \"Sales\" in x] + [\"Year_of_Release\"]].groupby(\n",
    "    \"Year_of_Release\"\n",
    ").sum().plot();"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Notez que l'implémentation de la méthode `plot()` dans `pandas` est basée sur `matplotlib`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "En utilisant le paramètre `kind`, vous pouvez changer le type du tracé en, par exemple, un *graphique à barres*. `matplotlib` est généralement assez flexible pour personnaliser les tracés. Vous pouvez modifier presque tout dans le graphique, mais vous devrez peut-être fouiller dans la [documentation](https://pandas.pydata.org/pandas-docs/stable/generated/pandas.DataFrame.plot.html) pour trouver le paramètres correspondants. Par exemple, le paramètre `rot` est responsable de l'angle de rotation des graduations sur l'axe x (pour les tracés verticaux):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:18:14.680814Z",
     "start_time": "2020-02-16T11:18:10.811821Z"
    }
   },
   "outputs": [],
   "source": [
    "df[[x for x in df.columns if \"Sales\" in x] + [\"Year_of_Release\"]].groupby(\n",
    "    \"Year_of_Release\"\n",
    ").sum().plot(kind=\"bar\", rot=45);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 3. Seaborn\n",
    "\n",
    "Passons maintenant à la bibliothèque `Seaborn`. `seaborn` est essentiellement une API de niveau supérieur basée sur la bibliothèque` matplotlib`. Entre autres choses, elle diffère de cette dernière en ce qu'elle contient des paramètres par défaut plus adéquats pour le traçage. En ajoutant `import seaborn as sns; sns.set()`dans votre code, les images de vos tracés deviendront beaucoup plus belles. En outre, cette bibliothèque contient un ensemble d'outils de visualisation complexes qui autrement (c'est-à-dire lors de l'utilisation de `matplotlib`) nécessiteraient une assez grande quantité de code.\n",
    "\n",
    "#### pairplot ()\n",
    "\n",
    "Jetons un coup d'œil au premier de ces tracés complexes, un *tracé de relations par paires*, qui crée une matrice de nuages de points par défaut. Ce type de graphique nous aide à visualiser la relation entre différentes variables dans un seule affichage."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:22:11.225077Z",
     "start_time": "2020-02-16T11:21:47.231962Z"
    }
   },
   "outputs": [],
   "source": [
    "# `pairplot()` may become very slow with the SVG format\n",
    "%config InlineBackend.figure_format = 'png'\n",
    "sns.pairplot(\n",
    "    df[[\"Global_Sales\", \"Critic_Score\", \"Critic_Count\", \"User_Score\", \"User_Count\"]]\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Comme vous pouvez le voir, les histogrammes de distribution se situent sur la diagonale de la matrice. Les graphiques restants sont des diagrammes de dispersion pour les paires d'entités correspondantes.\n",
    "\n",
    "#### distplot ()\n",
    "\n",
    "Il est également possible de tracer une distribution des observations avec le `distplot()` de `seaborn`.   \n",
    "Par exemple, regardons la distribution des notes des critiques: «Critique _Score». Par défaut, le tracé affiche un histogramme et [l'estimation de la densité du noyau](https://en.wikipedia.org/wiki/Kernel_density_estimation)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:23:40.215195Z",
     "start_time": "2020-02-16T11:23:38.639065Z"
    }
   },
   "outputs": [],
   "source": [
    "%config InlineBackend.figure_format = 'svg'\n",
    "sns.distplot(df[\"Critic_Score\"]);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "#### jointplot ()\n",
    "\n",
    "Pour examiner de plus près la relation entre deux variables numériques, on peut utiliser *joint plot*, qui est un croisement entre un nuage de points et un histogramme. Voyons comment les caractéristiques «Critic_Score» et «User_Score» sont liées."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:25:16.29023Z",
     "start_time": "2020-02-16T11:25:04.180873Z"
    }
   },
   "outputs": [],
   "source": [
    "sns.jointplot(x=\"Critic_Score\", y=\"User_Score\", data=df, kind=\"scatter\");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "#### boxplot ()\n",
    "\n",
    "Un autre type de tracé utile est une *Boîte à moustaches*. Comparons les notes des critiques pour les 5 plus grandes plateformes de jeux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:27:23.658708Z",
     "start_time": "2020-02-16T11:27:21.463503Z"
    }
   },
   "outputs": [],
   "source": [
    "top_platforms = (\n",
    "    df[\"Platform\"].value_counts().sort_values(ascending=False).head(5).index.values\n",
    ")\n",
    "sns.boxplot(\n",
    "    y=\"Platform\",\n",
    "    x=\"Critic_Score\",\n",
    "    data=df[df[\"Platform\"].isin(top_platforms)],\n",
    "    orient=\"h\",\n",
    ");"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "Cela vaut la peine de passer un peu plus de temps à discuter de la façon d'interpréter une Boîte à moustaches. Ses composants sont une *boîte* (évidemment, c'est pourquoi il est appelé *box plot*), les soi-disant *moustaches* et un certain nombre de points individuels ( *valeurs aberrantes*).\n",
    "\n",
    "L'encadré illustre à lui seul la répartition interquartile de la distribution; sa longueur est déterminée par les centiles $25\\% \\, (\\text{Q1})$ et $75\\% \\, (\\text{Q3})$. La ligne verticale à l'intérieur de la boîte marque la médiane ($50\\%$) de la distribution.\n",
    "\n",
    "Les moustaches sont les lignes qui partent de la boîte. Ils représentent la dispersion entière des points de données, en particulier les points qui tombent dans l'intervalle $(\\text{Q1} - 1.5 \\cdot \\text{IQR}, \\text{Q3} + 1.5 \\cdot \\text{IQR})$, où $\\text{IQR} = \\text{Q3} - \\text{Q1}$ est la [plage interquartile](https://en.wikipedia.org/wiki/Interquartile_range).\n",
    "\n",
    "Les valeurs aberrantes qui sortent de la plage délimitée par les moustaches sont tracées individuellement.\n",
    "\n",
    "#### heatmap() (carte de chaleur)\n",
    "\n",
    "Le dernier type de tracé que nous allons couvrir ici est une *carte thermique*. Une carte thermique vous permet de visualiser la distribution d'une variable numérique sur deux variables catégorielles. Visualisons les ventes totales de jeux par genre et par plate-forme de jeux."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:31:44.773399Z",
     "start_time": "2020-02-16T11:31:36.553787Z"
    }
   },
   "outputs": [],
   "source": [
    "platform_genre_sales = (\n",
    "    df.pivot_table(\n",
    "        index=\"Platform\", columns=\"Genre\", values=\"Global_Sales\", aggfunc=sum\n",
    "    )\n",
    "    .fillna(0)\n",
    "    .applymap(float)\n",
    ")\n",
    "sns.heatmap(platform_genre_sales, annot=True, fmt=\".1f\", linewidths=0.5);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 4. Plotly\n",
    "\n",
    "Nous avons examiné quelques outils de visualisation basés sur la bibliothèque `matplotlib`. Cependant, ce n'est pas la seule option en `Python`. Jetons un œil à la bibliothèque `plotly`. Plotly est une bibliothèque open source qui permet de créer des tracés interactifs dans un bloc-notes Jupyter sans avoir à utiliser Javascript.\n",
    "\n",
    "La vraie beauté des graphiques interactifs est qu'ils fournissent une interface utilisateur pour l'exploration détaillée des données. Par exemple, vous pouvez voir des valeurs numériques exactes en passant la souris sur des points, masquer des séries inintéressantes de la visualisation, zoomer sur une partie spécifique du tracé, etc.\n",
    "\n",
    "Avant de commencer, importons tous les modules nécessaires et initialisons `plotly` en appelant la fonction `init_notebook_mode()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:35:48.447896Z",
     "start_time": "2020-02-16T11:35:45.61457Z"
    }
   },
   "outputs": [],
   "source": [
    "import plotly\n",
    "import plotly.graph_objs as go\n",
    "from plotly.offline import download_plotlyjs, init_notebook_mode, iplot, plot\n",
    "\n",
    "init_notebook_mode(connected=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "#### Line plot\n",
    "\n",
    "Tout d'abord, construisons un *graphique linéaire* montrant le nombre de jeux sortis et leurs ventes par an."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:36:09.937076Z",
     "start_time": "2020-02-16T11:36:09.449715Z"
    }
   },
   "outputs": [],
   "source": [
    "years_df = (\n",
    "    df.groupby(\"Year_of_Release\")[[\"Global_Sales\"]]\n",
    "    .sum()\n",
    "    .join(df.groupby(\"Year_of_Release\")[[\"Name\"]].count())\n",
    ")\n",
    "years_df.columns = [\"Global_Sales\", \"Number_of_Games\"]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "`Figure` est la classe principale de la visualisation dans `plotly`. Il se compose des données (un tableau de lignes appelé «traces» dans cette bibliothèque) et du style (représenté par l'objet `layout`). Dans le cas le plus simple, vous pouvez appeler la fonction `iplot` pour renvoyer uniquement les `traces`.\n",
    "\n",
    "Le paramètre `show _link` bascule la visibilité des liens menant à la plateforme en ligne `plot.ly` dans vos graphiques. La plupart du temps, cette fonctionnalité n'est pas nécessaire, vous pouvez donc la désactiver en passant `show_ link = False` pour éviter les clics accidentels sur ces liens."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:36:19.52841Z",
     "start_time": "2020-02-16T11:36:15.123022Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a line (trace) for the global sales\n",
    "trace0 = go.Scatter(x=years_df.index, y=years_df[\"Global_Sales\"], name=\"Global Sales\")\n",
    "\n",
    "# Create a line (trace) for the number of games released\n",
    "trace1 = go.Scatter(\n",
    "    x=years_df.index, y=years_df[\"Number_of_Games\"], name=\"Number of games released\"\n",
    ")\n",
    "\n",
    "# Define the data array\n",
    "data = [trace0, trace1]\n",
    "\n",
    "# Set the title\n",
    "layout = {\"title\": \"Statistics for video games\"}\n",
    "\n",
    "# Create a Figure and plot it\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "iplot(fig, show_link=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "En option, vous pouvez enregistrer le tracé dans un fichier html:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:37:35.705087Z",
     "start_time": "2020-02-16T11:37:32.984251Z"
    }
   },
   "outputs": [],
   "source": [
    "plotly.offline.plot(fig, filename=\"years_stats.html\", show_link=False);"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "#### Bar chart (Diagramme à barres)\n",
    "\n",
    "Utilisons un *Diagramme à barres* pour comparer la part de marché des différentes plates-formes de jeu, ventilée par le nombre de nouvelles versions et par le total des revenus."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:42:55.875269Z",
     "start_time": "2020-02-16T11:42:55.784285Z"
    }
   },
   "outputs": [],
   "source": [
    "# Do calculations and prepare the dataset\n",
    "platforms_df = (\n",
    "    df.groupby(\"Platform\")[[\"Global_Sales\"]]\n",
    "    .sum()\n",
    "    .join(df.groupby(\"Platform\")[[\"Name\"]].count())\n",
    ")\n",
    "platforms_df.columns = [\"Global_Sales\", \"Number_of_Games\"]\n",
    "platforms_df.sort_values(\"Global_Sales\", ascending=False, inplace=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:43:01.155801Z",
     "start_time": "2020-02-16T11:42:59.112515Z"
    }
   },
   "outputs": [],
   "source": [
    "# Create a bar for the global sales\n",
    "trace0 = go.Bar(\n",
    "    x=platforms_df.index, y=platforms_df[\"Global_Sales\"], name=\"Global Sales\"\n",
    ")\n",
    "\n",
    "# Create a bar for the number of games released\n",
    "trace1 = go.Bar(\n",
    "    x=platforms_df.index,\n",
    "    y=platforms_df[\"Number_of_Games\"],\n",
    "    name=\"Number of games released\",\n",
    ")\n",
    "\n",
    "# Get together the data and style objects\n",
    "data = [trace0, trace1]\n",
    "layout = {\"title\": \"Market share by gaming platform\"}\n",
    "\n",
    "# Create a `Figure` and plot it\n",
    "fig = go.Figure(data=data, layout=layout)\n",
    "iplot(fig, show_link=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "#### Box plot\n",
    "\n",
    "`plotly` prend également en charge les *box plots*. Examinons la répartition des notes des critiques par genre de jeu."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2020-02-16T11:43:44.933981Z",
     "start_time": "2020-02-16T11:43:43.167675Z"
    }
   },
   "outputs": [],
   "source": [
    "data = []\n",
    "\n",
    "# Create a box trace for each genre in our dataset\n",
    "for genre in df.Genre.unique():\n",
    "    data.append(go.Box(y=df[df.Genre == genre].Critic_Score, name=genre))\n",
    "\n",
    "# Visualize\n",
    "iplot(data, show_link=False)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "En utilisant `plotly`, vous pouvez également créer d'autres types de visualisation. Même avec les paramètres par défaut, les tracés sont assez beaux. De plus, la bibliothèque facilite la modification de divers paramètres: couleurs, polices, légendes, annotations, etc."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "lang": "fr"
   },
   "source": [
    "## 5. Démonstration\n",
    "Pour vous exercer à l'analyse visuelle des données, vous pouvez effectuer [cette mission](https://www.kaggle.com/kashnitsky/a2-demo-analyzing-cardiovascular-data) où vous analyserez les données sur les maladies cardiovasculaires.\n",
    "\n",
    "## 6. Ressources utiles\n",
    "- The same notebook as an interactive web-based [Kaggle Kernel](https://www.kaggle.com/kashnitsky/topic-2-part-2-seaborn-and-plotly)\n",
    "- [\"Plotly for interactive plots\"](https://nbviewer.jupyter.org/github/Yorko/mlcourse.ai/blob/master/jupyter_english/tutorials/plotly_tutorial_for_interactive_plots_sankovalev.ipynb) - a tutorial by Alexander Kovalev within mlcourse.ai (full list of tutorials is [here](https://mlcourse.ai/tutorials))\n",
    "- [\"Bring your plots to life with Matplotlib animations\"](https://nbviewer.jupyter.org/github/Yorko/mlcourse.ai/blob/master/jupyter_english/tutorials/bring_your_plots_to_life_with_matplotlib_animations_kyriacos_kyriacou.ipynb) - a tutorial by Kyriacos Kyriacou within mlcourse.ai\n",
    "- [\"Some details on Matplotlib\"](https://nbviewer.jupyter.org/github/Yorko/mlcourse.ai/blob/master/jupyter_english/tutorials/some_details_in_matplotlib_pisarev_ivan.ipynb) - a tutorial by Ivan Pisarev within mlcourse.ai\n",
    "- Main course [site](https://mlcourse.ai), [course repo](https://github.com/Yorko/mlcourse.ai), and YouTube [channel](https://www.youtube.com/watch?v=QKTuw4PNOsU&list=PLVlY_7IJCMJeRfZ68eVfEcu-UcN9BbwiX)\n",
    "- Medium [\"story\"](https://medium.com/open-machine-learning-course/open-machine-learning-course-topic-2-visual-data-analysis-in-python-846b989675cd) based on this notebook\n",
    "- Course materials as a [Kaggle Dataset](https://www.kaggle.com/kashnitsky/mlcourse)\n",
    "- If you read Russian: an [article](https://habrahabr.ru/company/ods/blog/323210/) on Habrahabr with ~ the same material. And a [lecture](https://youtu.be/vm63p8Od0bM) on YouTube\n",
    "- Here is the official documentation for the libraries we used: [`matplotlib`](https://matplotlib.org/contents.html), [`seaborn`](https://seaborn.pydata.org/introduction.html) and [`pandas`](https://pandas.pydata.org/pandas-docs/stable/).\n",
    "- The [gallery](http://seaborn.pydata.org/examples/index.html) of sample charts created with `seaborn` is a very good resource.\n",
    "- Also, see the [documentation](http://scikit-learn.org/stable/modules/manifold.html) on Manifold Learning in `scikit-learn`.\n",
    "- Efficient t-SNE implementation [Multicore-TSNE](https://github.com/DmitryUlyanov/Multicore-TSNE).\n",
    "- \"How to Use t-SNE Effectively\", [Distill.pub](https://distill.pub/2016/misread-tsne/)."
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  },
  "nbTranslate": {
   "displayLangs": [
    "*"
   ],
   "hotkey": "alt-t",
   "langInMainMenu": true,
   "sourceLang": "en",
   "targetLang": "fr",
   "useGoogleTranslate": true
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {},
   "toc_section_display": true,
   "toc_window_display": false
  },
  "varInspector": {
   "cols": {
    "lenName": 16,
    "lenType": 16,
    "lenVar": 40
   },
   "kernels_config": {
    "python": {
     "delete_cmd_postfix": "",
     "delete_cmd_prefix": "del ",
     "library": "var_list.py",
     "varRefreshCmd": "print(var_dic_list())"
    },
    "r": {
     "delete_cmd_postfix": ") ",
     "delete_cmd_prefix": "rm(",
     "library": "var_list.r",
     "varRefreshCmd": "cat(var_dic_list()) "
    }
   },
   "types_to_exclude": [
    "module",
    "function",
    "builtin_function_or_method",
    "instance",
    "_Feature"
   ],
   "window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
